package com.java.wechat.controller;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.java.wechat.dao.ChatMsgDao;
import com.java.wechat.entity.ChatMsg;
import com.java.wechat.entity.User;
import com.java.wechat.entity.bo.UserBO;
import com.java.wechat.entity.vo.FriendRequestVO;
import com.java.wechat.entity.vo.MyFriendsVO;
import com.java.wechat.entity.vo.UserVO;
import com.java.wechat.enums.OperatorFriendRequestTypeEnum;
import com.java.wechat.enums.SearchFriendsStatusEnum;
import com.java.wechat.service.UserService;
import com.java.wechat.util.R;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

/**
 * @author jiangli
 * @date 2019/11/1 19:09
 */
@RestController
@RequestMapping("/u")
public class UserController {
	@Autowired
	private UserService userService;


	@PostMapping("/registOrLogin")
	public R registOrLogin(@RequestBody User user) {
		if (StrUtil.isEmpty(user.getUsername()) || StrUtil.isEmpty(user.getPassword())) {
			return R.error("用户名或密码不能为空!");
		}
		Boolean exist = userService.queryUsernameIsExist(user.getUsername());

		if (exist) { //登录
			user = userService.queryUserForLogin(user.getUsername(), user.getPassword());
			if (user == null) {
				return R.error("用户名或密码不正确!");
			}

		} else { //注册
            user = userService.saveUser(user);
        }
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(user,userVO);

		return R.ok().put("data",userVO);
	}

    /**
     * 上传用户头像
     */
    @PostMapping("/uploadFaceBase64")
	public R uploadFaceBase64(@RequestBody UserBO userBO) {
        return userService.uploadFaceBase64(userBO);
    }

	/**
	 * 更新昵称
	 */
	@PostMapping("/setNickname")
	public R setNickname(@RequestBody UserBO userBO) {
		if (StrUtil.isEmpty(userBO.getNickname())) {
			return R.error("昵称不能为空!");
		}
		return userService.setNickname(userBO);
	}

	/**
	 * 搜索好友接口, 根据账号做匹配查询而不是模糊查询
	 */
	@PostMapping("/search")
	public R searchUser(String myUserId, String friendUsername) throws Exception {
		if (StrUtil.isEmpty(myUserId) || StrUtil.isEmpty(friendUsername)) {
			return R.error("参数错误!");
		}

		// 前置条件 - 1. 搜索的用户如果不存在，返回[无此用户]
		// 前置条件 - 2. 搜索账号是你自己，返回[不能添加自己]
		// 前置条件 - 3. 搜索的朋友已经是你的好友，返回[该用户已经是你的好友]
		Integer status = userService.preconditionSearchFriends(myUserId, friendUsername);
		if (status.equals(SearchFriendsStatusEnum.SUCCESS.status)) {
			User friendUser = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getUsername,friendUsername));
			UserVO userVO = new UserVO();
			BeanUtils.copyProperties(friendUser, userVO);
			return R.ok().put("data",userVO);
		} else {
			String errorMsg = SearchFriendsStatusEnum.getMsgByKey(status);
			return R.error(errorMsg);
		}
	}

	/**
	 * 发送添加好友的请求
	 */
	@PostMapping("/addFriendRequest")
	public R addFriendRequest(String myUserId, String friendUsername) throws Exception {
		if (StrUtil.isEmpty(myUserId) || StrUtil.isEmpty(friendUsername)) {
			return R.error("参数错误!");
		}

		// 前置条件 - 1. 搜索的用户如果不存在，返回[无此用户]
		// 前置条件 - 2. 搜索账号是你自己，返回[不能添加自己]
		// 前置条件 - 3. 搜索的朋友已经是你的好友，返回[该用户已经是你的好友]
		Integer status = userService.preconditionSearchFriends(myUserId, friendUsername);
		if (status.equals(SearchFriendsStatusEnum.SUCCESS.status)) {
			userService.sendFriendRequest(myUserId, friendUsername);
			return R.ok();
		} else {
			String errorMsg = SearchFriendsStatusEnum.getMsgByKey(status);
			return R.error(errorMsg);
		}
	}

	/**
	 * 发送添加好友的请求
	 */
	@PostMapping("/queryFriendRequests")
	public R queryFriendRequests(String userId) {
		if (StrUtil.isEmpty(userId)) {
			return R.error("参数错误!");
		}

		List<FriendRequestVO> friendRequestVOS = userService.queryFriendRequestList(userId);
		return R.ok().put("data",friendRequestVOS);
	}

	/**
	 * 接受方 通过或者忽略朋友请求
	 */
	@PostMapping("/operFriendRequest")
	public R operFriendRequest(String acceptUserId, String sendUserId, Integer operType) {
		if (StrUtil.isEmpty(acceptUserId) || StrUtil.isEmpty(sendUserId) || operType == null) {
			return R.error("参数错误!");
		}

		// 1. 如果operType 没有对应的枚举值，则直接抛出空错误信息
		if (StringUtils.isBlank(OperatorFriendRequestTypeEnum.getMsgByType(operType))) {
			return R.error("参数错误!");
		}

		if (operType == OperatorFriendRequestTypeEnum.IGNORE.type) {
			// 2. 判断如果忽略好友请求，则直接删除好友请求的数据库表记录
			userService.deleteFriendRequest(sendUserId, acceptUserId);
		} else if (operType == OperatorFriendRequestTypeEnum.PASS.type) {
			// 3. 判断如果是通过好友请求，则互相增加好友记录到数据库对应的表
			//	   然后删除好友请求的数据库表记录
			userService.passFriendRequest(sendUserId, acceptUserId);
		}

		// 4. 数据库查询好友列表
		userService.queryMyFriends(acceptUserId);

		return R.ok();
	}

	/**
	 * 查询我的好友列表
	 */
	@PostMapping("/myFriends")
	public R myFriends(String userId) {
		if (StringUtils.isBlank(userId)) {
			return R.error("参数错误!");
		}
		List<MyFriendsVO> myFirends = userService.queryMyFriends(userId);
		return R.ok().put("data",myFirends);
	}

	/**
	 *
	 * 用户手机端获取未签收的消息列表
	 */
	@PostMapping("/getUnReadMsgList")
	public R getUnReadMsgList(String acceptUserId) {
		if (StringUtils.isBlank(acceptUserId)) {
			return R.error("参数错误!");
		}

		// 查询列表
		List<ChatMsg> unreadMsgList = userService.getUnReadMsgList(acceptUserId);

		return R.ok().put("data",unreadMsgList);
	}
}
